{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:48.544166Z",
     "start_time": "2025-01-17T04:57:42.943201Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 数据准备",
   "id": "1073bc64c567ba13"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:50.854231Z",
     "start_time": "2025-01-17T04:57:48.546170Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# 训练集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 测试集\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)\n"
   ],
   "id": "55788f25672e1ebe",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.601466Z",
     "start_time": "2025-01-17T04:57:50.856236Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        # img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "_mean, _std = cal_mean_std(train_ds)\n",
    "print(_mean, _std)\n",
    "\n",
    "transforms = nn.Sequential(\n",
    "    Normalize(mean=_mean, std=_std)\n",
    ")"
   ],
   "id": "7296e2499aa5be79",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.2860]) tensor([0.3205])\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 定义模型",
   "id": "b5e4f17ae389c008"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.626100Z",
     "start_time": "2025-01-17T04:57:59.602467Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=10):\n",
    "        super().__init__()\n",
    "        self.transform = transforms  # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()  # 展平层\n",
    "        self.linear_relu_stack = nn.Sequential(  # 线性层+激活层堆叠\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            # bn：批归一化层，对输入数据进行归一化处理，使得数据分布更加一致，加快模型收敛速度\n",
    "            # 一般而言，先batch norm 后 激活函数\n",
    "            # 1d：表示输入的维度是1\n",
    "            nn.BatchNorm1d(100), # num of features=100\n",
    "            nn.SELU(),\n",
    "            # 增加dropout，p=0.2表示以0.2的概率将某些神经元置0，防止过拟合\n",
    "            nn.AlphaDropout(p=0.2),\n",
    "        )\n",
    "        # 加layers_num-1个线性层+激活层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"linear{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"bn{i}\", nn.BatchNorm1d(100))\n",
    "            self.linear_relu_stack.add_module(f\"selu{i}\", nn.SELU())\n",
    "            # nn.AlphaDropout(p=0.2) # 注：这种方法不能成功添加，只能通过add_module方法添加\n",
    "            self.linear_relu_stack.add_module(f\"dropout{i}\", nn.AlphaDropout(p=0.2))  # 正确添加dropout\n",
    "            \n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"linear_out\", nn.Linear(100, 10))\n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        print(\"初始化权重\")\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)  # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias)  # 全零初始化偏置项\n",
    "        print(\"权重初始化完成\")\n",
    "\n",
    "    def forward(self, x):  # 前向传播\n",
    "        x = self.transform(x)  # 预处理,标准化\n",
    "        # 将输入数据 x 展平（Flatten），通常用于将多维数据转换为一维数据。\n",
    "        x = self.flatten(x)\n",
    "        # logits 是模型的原始输出，通常是未经过 Softmax 或 Sigmoid 处理的分数。\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算模型参数数量\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")  #np.prod是计算张量的元素个数\n",
    "    total += np.prod(value.shape) \n",
    "total"
   ],
   "id": "d3016623476b4fd4",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n",
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 10000\n",
      "Linear_20\tparamerters num: 100\n",
      "Linear_21\tparamerters num: 100\n",
      "Linear_21\tparamerters num: 100\n",
      "Linear_22\tparamerters num: 10000\n",
      "Linear_22\tparamerters num: 100\n",
      "Linear_23\tparamerters num: 100\n",
      "Linear_23\tparamerters num: 100\n",
      "Linear_24\tparamerters num: 10000\n",
      "Linear_24\tparamerters num: 100\n",
      "Linear_25\tparamerters num: 100\n",
      "Linear_25\tparamerters num: 100\n",
      "Linear_26\tparamerters num: 10000\n",
      "Linear_26\tparamerters num: 100\n",
      "Linear_27\tparamerters num: 100\n",
      "Linear_27\tparamerters num: 100\n",
      "Linear_28\tparamerters num: 10000\n",
      "Linear_28\tparamerters num: 100\n",
      "Linear_29\tparamerters num: 100\n",
      "Linear_29\tparamerters num: 100\n",
      "Linear_30\tparamerters num: 10000\n",
      "Linear_30\tparamerters num: 100\n",
      "Linear_31\tparamerters num: 100\n",
      "Linear_31\tparamerters num: 100\n",
      "Linear_32\tparamerters num: 10000\n",
      "Linear_32\tparamerters num: 100\n",
      "Linear_33\tparamerters num: 100\n",
      "Linear_33\tparamerters num: 100\n",
      "Linear_34\tparamerters num: 10000\n",
      "Linear_34\tparamerters num: 100\n",
      "Linear_35\tparamerters num: 100\n",
      "Linear_35\tparamerters num: 100\n",
      "Linear_36\tparamerters num: 10000\n",
      "Linear_36\tparamerters num: 100\n",
      "Linear_37\tparamerters num: 100\n",
      "Linear_37\tparamerters num: 100\n",
      "Linear_38\tparamerters num: 10000\n",
      "Linear_38\tparamerters num: 100\n",
      "Linear_39\tparamerters num: 100\n",
      "Linear_39\tparamerters num: 100\n",
      "Linear_40\tparamerters num: 1000\n",
      "Linear_40\tparamerters num: 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "275410"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练模型",
   "id": "8fb5dfcd77513c03"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.700829Z",
     "start_time": "2025-01-17T04:57:59.627105Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluate(model, data_loader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in data_loader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 前向传播\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 预测\n",
    "        preds = logits.argmax(axis=-1)  # 预测类别\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())  # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)  # 计算准确率\n",
    "    return np.mean(loss_list), acc  # # 返回验证集平均损失和准确率\n"
   ],
   "id": "24550945260b9755",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Save Best Model",
   "id": "6fd06a23a5bccc23"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.709231Z",
     "start_time": "2025-01-17T04:57:59.703835Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        self.save_dir = save_dir  # 保存路径\n",
    "        self.save_step = save_step  # 保存步数\n",
    "        self.save_best_only = save_best_only  # 是否只保存最好的模型\n",
    "        self.best_metric = -1  # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        # 创建保存路径\n",
    "        if not os.path.exists(self.save_dir):  # 如果不存在保存路径，则创建\n",
    "            os.makedirs(self.save_dir)\n",
    "\n",
    "    # 对象被调用时：当你将对象像函数一样调用时，Python 会自动调用 __call__ 方法。\n",
    "    # state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "    # metric 是指标，可以是验证集的准确率，也可以是其他指标\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return  # 不是保存步数，则直接返回\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None  # 必须传入metric\n",
    "            if metric >= self.best_metric:  # 如果当前指标大于最好的指标\n",
    "                # save checkpoint\n",
    "                # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"07_best.ckpt\"))\n",
    "                self.best_metric = metric  # 更新最好的指标\n",
    "        else:\n",
    "            # 保存模型\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "            # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n"
   ],
   "id": "e93aec97aec45c4e",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Early Stopping",
   "id": "3f9a004729448217"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.716089Z",
     "start_time": "2025-01-17T04:57:59.711234Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        self.patience = patience  # 多少个step没有提升就停止训练\n",
    "        self.min_delta = min_delta  # 最小的提升幅度\n",
    "        self.best_metric = -1  # 记录的最好的指标\n",
    "        self.counter = 0  # 计数器，记录连续多少个step没有提升\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果指标提升了\n",
    "            self.best_metric = metric  # 更新最好的指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加一\n",
    "\n",
    "    @property  # 使用@property装饰器，使得 对象.early_stop可以调用，不需要()\n",
    "    def early_stop(self):\n",
    "        # 如果计数器大于等于patience，则返回True，停止训练\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "d8fdc303a4d27c00",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练",
   "id": "b56dab87e8ff6485"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.729456Z",
     "start_time": "2025-01-17T04:57:59.717090Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def training(model,\n",
    "             train_loader,\n",
    "             test_loader,\n",
    "             epoch,\n",
    "             loss_fct,\n",
    "             optimizer,\n",
    "             tensorboard_callback=None,\n",
    "             save_ckpt_callback=None,\n",
    "             early_stop_callback=None,\n",
    "             eval_step=500,\n",
    "             ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0  # 全局步数\n",
    "    model.train()  # 训练模式\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 前向传播\n",
    "                logits = model(datas)\n",
    "                loss = loss_fct(logits, labels)  # 训练集损失\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "\n",
    "                # 反向传播\n",
    "                optimizer.zero_grad()  # 梯度清零\n",
    "                loss.backward()  # 反向传播\n",
    "                optimizer.step()  # 优化器更新参数\n",
    "\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 评估\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 评估模式\n",
    "                    # 验证集损失和准确率\n",
    "                    val_loss, val_acc = evaluate(model, test_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    model.train()  # 训练模式\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # model.state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), val_acc)\n",
    "                        # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 early stopping\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        early_stop_callback(val_acc)\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 早停，返回记录字典 record_dict\n",
    "\n",
    "                # 更新进度条和全局步数\n",
    "                pbar.update(1)  # 更新进度条\n",
    "                global_step += 1  # 全局步数加一\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict  # 训练结束，返回记录字典 record_dict\n"
   ],
   "id": "2602ccd3cb633f69",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "d111e077fd6e015"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T04:57:59.743030Z",
     "start_time": "2025-01-17T04:57:59.731459Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork()\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 2. 定义优化器 采用SGD优化器\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 3.save model checkpoint\n",
    "save_ckpt_callback = SaveCheckpointsCallback(save_dir=\"checkpoints\", save_step=500, save_best_only=True)\n",
    "\n",
    "# 4. early stopping\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.01)"
   ],
   "id": "8b42caff09582576",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:12:00.404754Z",
     "start_time": "2025-01-17T04:57:59.744036Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = model.to(device)  # 将模型移到GPU上\n",
    "\n",
    "# 训练过程\n",
    "record_dict = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    test_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "1b4d7f1cfe612c71",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "e63c335857d44d45838380a2ed651368"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 27 / global_step 101250\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:12:00.722533Z",
     "start_time": "2025-01-17T05:12:00.404754Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def plot_record_curves(record_dict, sample_step=1000):\n",
    "    # .set_index(\"step\") 将 step 列设置为 DataFrame 的索引\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    last_step = train_df.index[-1]  # 最后一步的步数\n",
    "\n",
    "    print(train_df)\n",
    "    print(val_df)\n",
    "\n",
    "    # 画图 \n",
    "    fig_num = len(train_df.columns)  # 画两张图,分别是损失和准确率\n",
    "\n",
    "    # plt.subplots：用于创建一个包含多个子图的图形窗口。\n",
    "    # 1：表示子图的行数为 1。\n",
    "    # fig_num：表示子图的列数，即子图的数量。\n",
    "    # figsize=(5 * fig_num, 5)：设置整个图形窗口的大小，宽度为 5 * fig_num，高度为 5。\n",
    "    # fig：返回的图形对象（Figure），用于操作整个图形窗口。\n",
    "    # axs：返回的子图对象（Axes 或 Axes 数组），用于操作每个子图。\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index 是 x 轴数据（通常是 step）。\n",
    "        # train_df[item] 是 y 轴数据（当前指标的值）。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=\"train:\" + item)\n",
    "        # val_df.index 是 x 轴数据。\n",
    "        # val_df[item] 是 y 轴数据。\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=\"val:\" + item)\n",
    "        axs[idx].grid()  # 显示网格\n",
    "        axs[idx].legend()  # 显示图例\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))  # 设置x轴刻度\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{x // 1000}k\", range(0, last_step + 1, 5000)))  # 设置x轴标签\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_record_curves(record_dict)"
   ],
   "id": "de28437c6058f608",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            loss     acc\n",
      "step                    \n",
      "0       2.831316  0.1875\n",
      "1000    0.525784  0.8125\n",
      "2000    0.628908  0.6875\n",
      "3000    0.604448  0.7500\n",
      "4000    0.935815  0.7500\n",
      "...          ...     ...\n",
      "97000   0.157335  0.9375\n",
      "98000   0.299218  0.9375\n",
      "99000   0.394699  0.8125\n",
      "100000  0.375630  0.8125\n",
      "101000  0.374741  0.8750\n",
      "\n",
      "[102 rows x 2 columns]\n",
      "            loss     acc\n",
      "step                    \n",
      "0       2.964400  0.0946\n",
      "3750    0.482902  0.8285\n",
      "7500    0.455815  0.8359\n",
      "11250   0.416665  0.8495\n",
      "15000   0.417905  0.8460\n",
      "18750   0.402646  0.8556\n",
      "22500   0.394337  0.8577\n",
      "26250   0.387922  0.8550\n",
      "30000   0.390521  0.8620\n",
      "33750   0.376146  0.8646\n",
      "37500   0.376362  0.8628\n",
      "41250   0.382431  0.8587\n",
      "45000   0.376819  0.8587\n",
      "48750   0.363798  0.8690\n",
      "52500   0.353706  0.8718\n",
      "56250   0.359597  0.8687\n",
      "60000   0.353246  0.8709\n",
      "63750   0.349843  0.8740\n",
      "67500   0.353403  0.8726\n",
      "71250   0.349104  0.8756\n",
      "75000   0.353204  0.8735\n",
      "78750   0.356735  0.8684\n",
      "82500   0.354936  0.8714\n",
      "86250   0.350986  0.8737\n",
      "90000   0.349238  0.8733\n",
      "93750   0.344443  0.8760\n",
      "97500   0.334324  0.8791\n",
      "101250  0.342909  0.8740\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:12:00.728354Z",
     "start_time": "2025-01-17T05:12:00.722533Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"train\"][-5:]",
   "id": "775b113bb78383fa",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.5717746019363403, 'acc': 0.75, 'step': 101246},\n",
       " {'loss': 0.5282015204429626, 'acc': 0.625, 'step': 101247},\n",
       " {'loss': 0.4660200774669647, 'acc': 0.875, 'step': 101248},\n",
       " {'loss': 0.11408207565546036, 'acc': 1.0, 'step': 101249},\n",
       " {'loss': 0.18981224298477173, 'acc': 1.0, 'step': 101250}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:12:00.735909Z",
     "start_time": "2025-01-17T05:12:00.728354Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"val\"][-10:]",
   "id": "dbb21c010aaef95e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.3534025780439377, 'acc': 0.8726, 'step': 67500},\n",
       " {'loss': 0.349104097622633, 'acc': 0.8756, 'step': 71250},\n",
       " {'loss': 0.3532041597723961, 'acc': 0.8735, 'step': 75000},\n",
       " {'loss': 0.35673485246300696, 'acc': 0.8684, 'step': 78750},\n",
       " {'loss': 0.35493559839725497, 'acc': 0.8714, 'step': 82500},\n",
       " {'loss': 0.3509863699346781, 'acc': 0.8737, 'step': 86250},\n",
       " {'loss': 0.34923787285685537, 'acc': 0.8733, 'step': 90000},\n",
       " {'loss': 0.3444426462560892, 'acc': 0.876, 'step': 93750},\n",
       " {'loss': 0.33432422787845134, 'acc': 0.8791, 'step': 97500},\n",
       " {'loss': 0.34290923447608945, 'acc': 0.874, 'step': 101250}]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 评估以及上线",
   "id": "1fa2f200745f7b63"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:12:00.752280Z",
     "start_time": "2025-01-17T05:12:00.735909Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = NeuralNetwork()  #上线时加载模型\n",
    "model = model.to(device)  # 将模型移到GPU上"
   ],
   "id": "b106406c03208c15",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "初始化权重\n",
      "权重初始化完成\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:12:40.224797Z",
     "start_time": "2025-01-17T05:12:38.759542Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 加载最好的模型\n",
    "# torch.load：加载保存的模型权重或整个模型。\n",
    "# \"checkpoints/best.ckpt\"：模型权重文件路径。\n",
    "# weights_only=True：仅加载模型的权重，而不是整个模型（包括结构和参数）。这是 PyTorch 2.1 引入的新特性，用于增强安全性。\n",
    "# map_location=device：将模型加载到当前设备（GPU或CPU）。\n",
    "model.load_state_dict(torch.load(\"checkpoints/07_best.ckpt\", weights_only=True, map_location=device))  # 加载最好的模型\n",
    "\n",
    "model.eval()  # 评估模式\n",
    "loss, acc = evaluate(model, test_loader, loss_fct)\n",
    "print(f\"Test loss: {loss:.4f}, Test acc: {acc:.4f}\")"
   ],
   "id": "26cdacda63d5388e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.3343, Test acc: 0.8791\n"
     ]
    }
   ],
   "execution_count": 15
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
